package com.shujia


object Code24ListFunction {
  def main(args: Array[String]): Unit = {
    /**
     * List 高阶函数
     * 1.Map 函数
     * 格式：   要求传入一个函数，函数的类型为 (List元素类型) => 返回结果类型
     * 注意：Map中函数的返回值类型可以没有，但是不规范，不推荐使用
     * 作用：  将集合中的每个元素取出，将其作为函数的参数值，传入函数中进行执行，
     * 并得到结果，将结果保存到新的List集合中
     * 形式： 传入一条数据 返回一条结果数据
     * 应用场景：对获取到的每一条数据进行转换
     *
     * 2.foreach 函数
     * 格式： 要求传入一个函数，函数的类型为 (List元素类型) => Unit
     * 注意：foreach传入的函数，要求没有返回值
     * 作用：  将集合中的每个元素取出，将其作为函数的参数值，传入函数中进行执行 并没有返回结果
     * 形式： 传入一条数据 无返回结果数据
     * 应用场景： 打印，数据插入Mysql等。。。
     *
     * 3.flatMap 函数
     *    格式： 要求传入一个函数，函数的类型为 (List元素类型) => 容器子类
     *    注意： 返回值要求给定一个集合 List中的元素不一定是一个数组或者容器
     *    作用： 扁平化操作 将集合中的每个元素取出，将其作为函数的参数值，传入函数中进行执行，并返回一个集合
     *    形式： 传入一条数据 并将容器中所有的元素取出放入一个最终的结果容器中
     *    应用场景：做数据的扁平化操作
     *
     * 4.groupBy 函数
     *    格式： 要求传入一个函数，函数的类型为 (List元素类型) => 任意元素
     *    作用： 对分组的过程进行选择Key
     *    形式： 传入一个分组的Key 返回相同Key对应的一组数据
     *    应用场景：对数据进行分组统计
     *
     */

    val intList: List[Int] = List(4, 3, 1, 2, 6, 5, 7, 8, 3, 3, 2)
    // 需求：将List中所有元素的数据进行平方
    val newListRes: List[Int] = intList.map(mapSeq)
    println(newListRes)

    // 1.map
    val newListRes2: List[Int] = intList.map(
      (int: Int) => {
        int * int
      }
    )
    println(newListRes2)

    val newListRes3: List[Int] = intList.map(
      int => int * int
    )
    println(newListRes3)

    //
    val unitsList: List[Unit] = intList.map(
      int => println(int * int)
    )

    // 2.foreach
    intList.foreach(println)


    val wordsList: List[String] = List("hello world hello Scala hello Java"
      , "hello hadoop hello hadoop hello spark"
      , "hello hadoop hello hadoop hello spark"
    )


//    wordsList
//      .map(
//        word => word.split(" ")
//      ).foreach(
//      arr => println(arr.toList)
//    )

    // List(hello, world, hello, Scala, hello, Java)
    val splitRes: List[Array[String]] =
      wordsList
        .map(
          word => word.split(" ")
        )


    val flatMapResList: List[String] = splitRes.flatMap(
      (arr: Array[String]) => {
        arr
      }
    )
    println(flatMapResList)

//    val chars: List[Char] = splitRes.flatMap(
//      (arr: Array[String]) => {
//        arr(0)
//      }
//    )


    // 将Map和FlatMap的上述操作合并一起
    val flatMapResList2: List[String] = wordsList.flatMap(
      (oneLine: String) => {
        // 返回该结果
        oneLine.split(" ")
      }
    )
    println(flatMapResList2)


    // groupBy需要给定一个分组依据

    val groupByList: List[(String, List[String])] = flatMapResList2.groupBy(
      (word: String) => word
    ).toList
    println(groupByList)

    groupByList.map(
      // (Scala,List(Scala))
      (oneElem:(String, List[String])) => {
        val word: String = oneElem._1
        val oneWordList: List[String] = oneElem._2
        word +","+oneWordList.size
      }
    ).foreach(println)



  }

  def mapSeq(num: Int): Int = {
    num * num
  }
}
